#ifndef __TListaPoro__
#define __TListaPoro__

#include <iostream>
#include <string>
#include "tporo.h"
#include "tvectorporo.h"
#include "tpilaporo.h"

using namespace std;
/*
class TListaNodo
{
   friend class TListaPosicion;
   friend class TListaPoro;
   public:
      // FORMA CANÓNICA
      // Constructor por defecto
      TListaNodo ();
      // Constructor de copia
      TListaNodo (TListaNodo &);
      // Destructor
      ~TListaNodo ();
      // Sobrecarga del operador asignación
      TListaNodo & operator=(const TListaNodo &);

   private:
      // El elemento del nodo
      TPoro e;
      // El nodo anterior
      TListaNodo *anterior;
      // El nodo siguiente
      TListaNodo *siguiente;

};


class TListaPosicion
{
   friend class TListaNodo;
   friend class TListaPoro;
   public:
      // FORMA CANÓNICA
      // Constructor por defecto
      TListaPosicion();
      // Constructor de copia
      TListaPosicion(TListaPosicion &);
      // Destructor
      ~TListaPosicion();
      // Sobrecarga del operador asignación
      TListaPosicion& operator=(TListaPosicion &);
      // MÉTODOS
      // Sobrecarga del operador igualdad
      bool operator==(TListaPosicion &);
      // Devuelve la posición anterior
      TListaPosicion Anterior();
      // Devuelve la posición siguiente
      TListaPosicion Siguiente();
      // Devuelve TRUE si la posición no apunta a una lista, FALSE en caso contrario
      bool EsVacia();

   private:
      // Puntero a un nodo de la lista
      TListaNodo *pos;
};


class TListaPoro
{
   friend class TListaPosicion;
   friend class TListaNodo;
   // Sobrecarga del operador salida
   friend ostream & operator<<(ostream &, TListaPoro &);

   public:
      //FORMA CANÓNICA
      // Constructor por defecto
      TListaPoro();
      // Constructor de copia
      TListaPoro (TListaPoro &);
      // Destructor
      ~TListaPoro ();
      // Sobrecarga del operador asignación
      TListaPoro & operator=( TListaPoro &);
      //MÉTODOS
      // Sobrecarga del operador igualdad
      bool operator==(TListaPoro &);
      // Sobrecarga del operador suma
      TListaPoro operator+(TListaPoro &);
      // Sobrecarga del operador resta
      TListaPoro operator-(TListaPoro &);
      // Devuelve true si la lista está vacía, false en caso contrario
      bool EsVacia();
      // Inserta el elemento en la lista
      bool Insertar(TPoro &);
      // Busca y borra el elemento
      bool Borrar(TPoro &);
      // Borra el elemento que ocupa la posición indicada
      bool Borrar(TListaPosicion &);
      // Obtiene el elemento que ocupa la posición indicada
      TPoro Obtener(TListaPosicion &);
      // Devuelve true si el elemento está en la lista, false en caso contrario
      bool Buscar(TPoro &);
      // Devuelve la longitud de la lista
      int Longitud();
      // Devuelve la primera posición en la lista
      TListaPosicion Primera();
      // Devuelve la última posición en la lista
      TListaPosicion Ultima();

   private:
      // El elemento del nodo
      TPoro e;
      // Primer elemento de la lista
      TListaNodo *primero;
      // Ultimo elemento de la lista
      TListaNodo *ultimo;

};
*/

class TListaNodo
{
   friend class TListaPosicion;
   friend class TListaPoro;
   public:
      TListaNodo ();
      TListaNodo (TListaNodo &);
      ~TListaNodo ();
      TListaNodo & operator=(const TListaNodo &);

   private:
      TPoro e;
      TListaNodo *anterior;
      TListaNodo *siguiente;
};

class TListaPosicion
{
   friend class TListaNodo;
   friend class TListaPoro;
   public:
      TListaPosicion();
      TListaPosicion(TListaPosicion &);
      ~TListaPosicion();
      TListaPosicion& operator=(TListaPosicion &);
      bool operator==(TListaPosicion &);
      TListaPosicion Anterior();
      TListaPosicion Siguiente();
      bool EsVacia();

   private:
      TListaNodo *pos;
};

class TListaPoro
{
   friend class TListaPosicion;
   friend class TListaNodo;
   friend ostream & operator<<(ostream &, TListaPoro &);

   public:
      TListaPoro();
      TListaPoro (TListaPoro &);
      ~TListaPoro ();
      TListaPoro & operator=( TListaPoro &);
      bool operator==(TListaPoro &);
      TListaPoro operator+(TListaPoro &);
      TListaPoro operator-(TListaPoro &);
      bool EsVacia();
      bool Insertar(TPoro &);
      bool Borrar(TPoro &);
      bool Borrar(TListaPosicion &);
      TPoro Obtener(TListaPosicion &);
      bool Buscar(TPoro &);
      int Longitud();
      TListaPosicion Primera();
      TListaPosicion Ultima();

   private:
      TListaNodo *primero;
      TListaNodo *ultimo;
};

#endif
